package com.qkjia.zqkspringshell.yuanma;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.AnnotationAwareOrderComparator;
import org.springframework.core.annotation.Order;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.shell.ExitRequest;
import org.springframework.shell.InputProvider;
import org.springframework.shell.jline.FileInputProvider;
import org.springframework.shell.standard.ShellComponent;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.stream.Collectors;

/**
 * SpringShell源码分析-ApplicationRunner

 * SpringShell应用启动时, 会默认向IOC容器中注入两个ApplicationRunner:
 * ScriptShellApplicationRunner 和 InteractiveShellApplicationRunner,
 * 其中ScriptShellApplicationRunner 的优先级要高于InteractiveShellApplicationRunner.

 */
@ShellComponent
public class ApplicationRunner {
//    ApplicationRunner 定义
//1.1 InteractiveShellApplicationRunner
//    InteractiveShellApplicationRunner 指定顺序为0

/*    @Order(InteractiveShellApplicationRunner.PRECEDENCE)
    public class InteractiveShellApplicationRunner implements ApplicationRunner {
        // ...
    }*/

//    .2 ScriptShellApplicationRunner
//    定义时, 指定顺序为InteractiveShellApplicationRunner 的顺序-100, 也就是优先级大于InteractiveShellApplicationRunner, 通过这种方式限制优先注册ScriptShellApplicationRunner.

/*
    @Order(InteractiveShellApplicationRunner.PRECEDENCE - 100) // Runs before InteractiveShellApplicationRunner
    public class ScriptShellApplicationRunner implements ApplicationRunner {
        // ...
    }
*/

//        1.3 配置类JLineShellAutoConfiguration
//    配置类JLineShellAutoConfiguration中注入 interactiveApplicationRunner 和 scriptApplicationRunner 组件, 有条件注入, 默认为true.

//    @Configuration
//    public class JLineShellAutoConfiguration {
/*        @Bean
        @ConditionalOnProperty(prefix = SPRING_SHELL_INTERACTIVE, value = InteractiveShellApplicationRunner.ENABLED, havingValue = "true", matchIfMissing = true)
        public ApplicationRunner interactiveApplicationRunner(Parser parser, Environment environment) {
            return new InteractiveShellApplicationRunner(lineReader(), promptProvider, parser, shell, environment);
        }

        @Bean
        @ConditionalOnProperty(prefix = SPRING_SHELL_SCRIPT, value = ScriptShellApplicationRunner.ENABLED, havingValue = "true", matchIfMissing = true)
        public ApplicationRunner scriptApplicationRunner(Parser parser, ConfigurableEnvironment environment) {
            return new ScriptShellApplicationRunner(parser, shell, environment);
        }
    }*/

//        2. 源码分析
//    本文只设计ApplicationRunner的运行流程, 不涉及bean 初始化等其它流程.

/*            1. 启动容器, 遍历执行自定义ApplicationRunner
    SpringShell 应用通过 SpringApplication.run(SpringShellApplication.class, args)启动项目, 会调用org.springframework.boot.SpringApplication#run(java.lang.String…) 方法
    org.springframework.boot.SpringApplication#run(java.lang.String…) 会对容器进行初始化, 创建bean 等操作, 然后会调用所有自定义的ApplicationRunner 的run方法
    // 源码: org.springframework.boot.SpringApplication#callRunners
    private void callRunners(ApplicationContext context, ApplicationArguments args) {
        // 获取容器中定义的所有ApplicationRunner
        List<Object> runners = new ArrayList();
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
        AnnotationAwareOrderComparator.sort(runners);
        Iterator var4 = (new LinkedHashSet(runners)).iterator();

        // 遍历所有ApplicationRunner, 执行其run方法.
        while(var4.hasNext()) {
            Object runner = var4.next();
            if (runner instanceof ApplicationRunner) {
                // callRunner()方法里就是执行runner.run(args) 方法
                this.callRunner((ApplicationRunner)runner, args);
            }

            if (runner instanceof CommandLineRunner) {
                this.callRunner((CommandLineRunner)runner, args);
            }
        }
    }*/

   /*     2. 优先执行ScriptShellApplicationRunner.run(args)方法
    首先对所有启动参数做一遍过滤, 获取所有的脚本参数, 并创建文件列表. 也就是说, 只要启动参数包含脚本参数, 则忽略所有其它参数.
            如果启动参数中,包含脚本参数:
    关闭交互式方式, 在执行InteractiveShellApplicationRunner.run 方法时, 会先判断是否
    遍历脚本列表, 为每个脚本文件创建一个InputProvider, 每个脚本都作为一个独立的输入源, 执行sell.run()方法
    每个脚本读到最后都返回null, shell.run()读到null时, 结束shell.run()中的循环.
            如果启动参数, 不包含脚本参数, 则此ApplicationRunner运行结束, 接下来运行下一个ApplicationRunner, 即InteractiveShellApplicationRunner
//  org.springframework.shell.jline.ScriptShellApplicationRunner#run**
    @Override
    public void run(ApplicationArguments args) throws Exception {
    # 1.获取启动参数中所有以@开头的参数, 为每个脚本参数创建一个File对象, 组成File列表
        List<File> scriptsToRun = args.getNonOptionArgs().stream()
                .filter(s -> s.startsWith("@"))
                .map(s -> new File(s.substring(1)))
                .collect(Collectors.toList());

        boolean batchEnabled = environment.getProperty(SPRING_SHELL_SCRIPT_ENABLED, boolean.class, true);
*/
 /*   # 2.如果脚本参数不为空
        if (!scriptsToRun.isEmpty() && batchEnabled) {
            // 3.设置关闭交互式方式, 保证运行为脚本的所有命令之后, 直接关闭程序
            InteractiveShellApplicationRunner.disable(environment);
            // 4.遍历每个脚本, 为每个脚本创建一个命令提供源, 依次执行shell的run方法.
            for (File file : scriptsToRun) {
                try (Reader reader = new FileReader(file);
                     FileInputProvider inputProvider = new FileInputProvider(reader, parser)) {
                    shell.run(inputProvider);
                }
            }
        }
    }*/

/*        3. 其次执行 InteractiveShellApplicationRunner.run(args)方法
    首先判断, 交互方式是否打开. 即在ScriptShellApplicationRunner.run中有没有关闭交互时方式
    如果交互方式打开, 则创建控制台命令输入源, 执行shell的run方法. shell 的run 会进入无限循环, 当用户输入为null 时, 则终止循环, 退出程序
    // 源码: org.springframework.shell.jline.InteractiveShellApplicationRunner#run
    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 获取交互方式是否打开, 如果ScriptShellApplicationRunner 中执行了第三步, 此处获取即为false.
        boolean interactive = isEnabled();

        // 如果交互方式打开(为true), 则创建控制台输入源, 执行shell 的run方法
        if (interactive) {
            InputProvider inputProvider = new JLineInputProvider(lineReader, promptProvider);
            shell.run(inputProvider);
        }
    }*/

/*        4. 核心方法Shell.run(InputProvider)
    Shell的run方法是一个无限循环, 会循环地从传入的InputProvider中获取命令, 如果获取为空, 则跳出循环, 结束run方法; 否则解析命令, 执行命令,并将返回值输出.
    run方法从InputProvider 中是一条命令一条命令读取的, 且只有当返回值为null时, 才会跳出run方法, 结束方法运行. 这一点在自定义Runner时需要注意.
    // 源码: org.springframework.shell.Shell#run
    public void run(InputProvider inputProvider) throws IOException {
        // 自定义循环退出码
        Object result = null;

        // 无限循环, 知道result为退出嘛
        while (!(result instanceof ExitRequest)) {
            Input input;

            // 从输入源中读取一条输入
            try {
                input = inputProvider.readInput();
            }
            catch (Exception e) {
                resultHandler.handleResult(e);
                continue;
            }

            // 当读取的输入为null时, 跳出循环, 结束此shell的运行
            if (input == null) {
                break;
            }

            // 执行命令, 相应结果
            result = evaluate(input);

            // 处理结果, 回显终端
            if (result != NO_INPUT && !(result instanceof ExitRequest)) {
                resultHandler.handleResult(result);
            }
        }
    }*/

}
